{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.io.wavfile import read\n",
    "import numpy as np\n",
    "#%matplotlib widget\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import librosa\n",
    "import soundfile as sf\n",
    "import json\n",
    "import re \n",
    "import io\n",
    "from librosa.core.spectrum import power_to_db\n",
    "import scipy\n",
    "\n",
    "def FP2FIX(Val, Prec):\n",
    "    if np.isscalar(Val):\n",
    "        return int(Val * ((1<<Prec) - 1))\n",
    "    else:\n",
    "        return (Val * ((1<<Prec) - 1)).astype(np.int32)\n",
    "def FIX2FP(Val, Prec):\n",
    "    if np.isscalar(Val):\n",
    "        return float(Val) / float(1<<Prec)\n",
    "    else:\n",
    "        return Val.astype(np.float32) / float(1<<Prec)\n",
    "def gap_mulsRN(x, y, N):\n",
    "    if np.isscalar(x) and np.isscalar(y):\n",
    "        return int(int(x) * int(y) + (1<<(N-1))) >> N\n",
    "    else:\n",
    "        return (x.astype(np.int32) * y.astype(np.int32) + (1<<(N-1))).astype(np.int32) >> N\n",
    "def qsnr(orig, quant):\n",
    "    \"\"\"Calculate the QSNR between two tensors\n",
    "    \"\"\"\n",
    "    qerr = orig - quant\n",
    "    sum_err = np.sum(qerr * qerr)\n",
    "    sum_orig = np.sum(orig * orig)\n",
    "    if sum_err > 0:\n",
    "        if sum_orig < sum_err:\n",
    "            if sum_orig == 0:\n",
    "                return -math.inf\n",
    "            else:\n",
    "                # Means error is larger than signal\n",
    "                return -int(round(10 * math.log10(sum_err/sum_orig), 0))\n",
    "        # Error portion of signal\n",
    "        return int(round(10 * math.log10(sum_orig/sum_err), 0))\n",
    "    # Means no error\n",
    "    return math.inf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_path = \"samples/yes.wav\"\n",
    "data, samplerate = sf.read(file_path)\n",
    "#data = np.clip(data*3, -1, 1)\n",
    "\n",
    "with open(\"MfccConfig.json\", \"r\") as f:\n",
    "    config = json.load(f)\n",
    "\n",
    "frame_size = config['frame_size']\n",
    "frame_step = config['frame_step']\n",
    "n_fft = config['n_fft']\n",
    "n_mels = config['n_mels']\n",
    "fmin = config['fmin']\n",
    "fmax = config['fmax']\n",
    "dtype = config.get('dtype', \"int\")\n",
    "high_prec = config.get('use_high_prec', False) or dtype == \"fix32_scal\"\n",
    "use_power = False\n",
    "rad4 = round(math.log(n_fft//2, 4)) == math.log(n_fft//2, 4)\n",
    "ndct = config.get('n_dct', False)\n",
    "\n",
    "frame_idx = 20\n",
    "frame = data[frame_idx*config['frame_step']:frame_idx*config['frame_step']+config['frame_size']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'n_fft': 512,\n",
       " 'win_func': 'hanning',\n",
       " 'frame_size': 400,\n",
       " 'frame_step': 160,\n",
       " 'sample_rate': 16000,\n",
       " 'n_mels': 40,\n",
       " 'n_dct': 40,\n",
       " 'fmin': 20.0,\n",
       " 'fmax': 4000.0,\n",
       " 'dtype': 'float16',\n",
       " 'use_librosa': True}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2.58125841e+03, -2.82931156e+03, -2.84083285e+03, ...,\n",
       "        -2.80648765e+03, -2.84941802e+03, -2.90688134e+03],\n",
       "       [-7.42654009e+01, -1.50694569e+01,  2.14191916e+01, ...,\n",
       "        -2.25321745e+00, -3.55597362e+01, -1.85639080e+01],\n",
       "       [ 3.37116962e+01,  6.46678093e+01,  1.10413046e+02, ...,\n",
       "         9.28208380e+01,  8.22531848e+01,  6.17329813e+01],\n",
       "       ...,\n",
       "       [ 4.07039198e+00,  7.98904601e+00,  8.90213326e+00, ...,\n",
       "        -1.46338874e+01, -3.96503683e+00,  1.30272553e+01],\n",
       "       [ 1.03983748e+01,  7.80702608e-01, -6.67624914e+00, ...,\n",
       "         9.67274701e+00,  2.94455473e+00,  5.50445468e+00],\n",
       "       [-3.40372131e+00,  1.08643042e+01, -2.66690252e+00, ...,\n",
       "        -1.35489864e+01,  9.08998249e-01, -4.47300300e+00]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from librosa.filters import get_window\n",
    "from librosa import util\n",
    "librosa_fft_window = get_window(\"hann\", frame_size, fftbins=True)\n",
    "# Pad the window out to n_fft size\n",
    "librosa_fft_window = util.pad_center(librosa_fft_window, n_fft)\n",
    "\n",
    "stft = librosa.core.spectrum.stft(data, n_fft, frame_step, frame_size, center=False, pad_mode=\"constant\")\n",
    "spect = np.abs(stft) ** (1 if not use_power else 2)\n",
    "mel_basis = librosa.filters.mel(samplerate, n_fft, n_mels, fmin, fmax)\n",
    "mel_spect = np.dot(mel_basis, spect)\n",
    "logmel = power_to_db(mel_spect, top_db=None)\n",
    "mfcc = scipy.fftpack.dct(logmel, axis=0, type=2, norm=None)\n",
    "with open(\"ground_truth.h\", \"w\") as f:\n",
    "    f.write(f\"float Ground_Truth_{frame_size}_{n_fft} = {{\\n\")\n",
    "    for elem in mfcc.T.flatten():\n",
    "        f.write(f\"{elem}, \")\n",
    "    f.write(\"};\\n\")\n",
    "mfcc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fa114936ac0>]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(mfcc.T[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'results.txt'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-adfa22a1eccc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m \u001b[0mOUT_LIST\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mGAP_Shift\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGAP_out_preemph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGAP_out_window\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGAP_out_fft\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGAP_out_spect\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGAP_melspect\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGAP_shift_BF\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGAP_log\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGAP_Norm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGAP_out_dct\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGAP_out_fft_shift\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"results.txt\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"r\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     23\u001b[0m     \u001b[0mstr_replace\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     24\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mline\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreadlines\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'results.txt'"
     ]
    }
   ],
   "source": [
    "GAP_Shift \t\t\t= {\"Matcher\": re.compile(r\"Shift\\s=\\s(?P<value_list>[-0-9]+)\")\t\t\t\t\t, \"values\": []}\n",
    "GAP_out_preemph \t= {\"Matcher\": re.compile(r\"out_preemph_c = \\[\\t*(?P<value_list>[^\\)\\]]+)]\\)\")\t, \"values\": []}\n",
    "GAP_out_window  \t= {\"Matcher\": re.compile(r\"out_window_c = \\[\\t*(?P<value_list>[^\\)\\]]+)]\\)\")\t, \"values\": []}\n",
    "if dtype == 'fix32_scal':\n",
    "    GAP_out_fft \t\t= {\"Matcher\": re.compile(r\"out_swapped_fft = \\[\\t*(?P<value_list>[^\\)\\]]+)]\\)\") , \"values\": []}\n",
    "    GAP_out_fft_shift   = {\"Matcher\": re.compile(r\"out_fft_shift = \\[\\t*(?P<value_list>[^\\)\\]]+)]\\)\"), \"values\": []}    \n",
    "else:\n",
    "    GAP_out_fft \t\t= {\"Matcher\": re.compile(r\"out_rfft = \\[\\t*(?P<value_list>[^\\)\\]]+)]\\)\") , \"values\": []}\n",
    "    GAP_out_fft_shift   = {\"Matcher\": re.compile(r\"out_fft_shift = \\[\\t*(?P<value_list>[^\\)\\]]+)]\\)\"), \"values\": []}\n",
    "if not use_power:\n",
    "    GAP_out_spect \t= {\"Matcher\": re.compile(r\"out_mag = \\[\\t*(?P<value_list>[^\\)\\]]+)]\\)\")\t, \"values\": []}\n",
    "else:\n",
    "    GAP_out_spect \t= {\"Matcher\": re.compile(r\"out_power = \\[\\t*(?P<value_list>[^\\)\\]]+)]\\)\")\t\t, \"values\": []}\n",
    "GAP_melspect \t\t= {\"Matcher\": re.compile(r\"out_melfilterbank = \\[\\t*(?P<value_list>[^\\)\\]]+)]\\)\"), \"values\": []}\n",
    "GAP_shift_BF \t\t= {\"Matcher\": re.compile(r\"shift_BF = \\[\\t*(?P<value_list>[^\\)\\]]+)]\\)\")\t\t, \"values\": []}\n",
    "GAP_log \t\t\t= {\"Matcher\": re.compile(r\"out_log = \\[\\t*(?P<value_list>[^\\)\\]]+)\\]\\)\")\t\t, \"values\": []}\n",
    "GAP_Norm \t\t\t= {\"Matcher\": re.compile(r\"Norm\\s=\\s(?P<value_list>[0-9]+)\")\t\t\t\t\t, \"values\": []}\n",
    "GAP_norm_clip \t\t= {\"Matcher\": re.compile(r\"out_norm_clip = \\[\\t*(?P<value_list>[^\\)\\]]+)]\\)\")\t, \"values\": []}\n",
    "GAP_out_dct \t\t= {\"Matcher\": re.compile(r\"out_dct_ii = \\[\\t*(?P<value_list>[^\\)\\]]+)]\\)\")\t\t, \"values\": []}\n",
    "\n",
    "OUT_LIST = [GAP_Shift, GAP_out_preemph, GAP_out_window, GAP_out_fft, GAP_out_spect, GAP_melspect, GAP_shift_BF, GAP_log, GAP_Norm, GAP_out_dct, GAP_out_fft_shift]\n",
    "with open(\"results.txt\", \"r\") as f:\n",
    "    str_replace = \"\"\n",
    "    for line in f.readlines():\n",
    "        str_replace += line.replace(\"np.array([\\n\", \"[\")\n",
    "    buf =io.StringIO(str_replace)\n",
    "    for line in buf:\n",
    "        for match in OUT_LIST:\n",
    "            m = match[\"Matcher\"].search(line)\n",
    "            if m:\n",
    "                match[\"values\"].append(np.array(eval(m['value_list'])))\n",
    "\n",
    "# fixed point info extracted at runtime\n",
    "Shift = np.array(GAP_Shift['values'])\n",
    "fft_shift_buff = np.array(GAP_out_fft_shift['values'])\n",
    "Norm = np.array(GAP_Norm['values'])\n",
    "melspect_shift_buff = np.array(GAP_shift_BF['values'])\n",
    "\n",
    "# values\n",
    "gap_windows = np.array(GAP_out_window['values'])\n",
    "gap_fft = np.array(GAP_out_fft['values'])\n",
    "gap_spect = np.array(GAP_out_spect['values'])\n",
    "gap_melspect = np.array(GAP_melspect['values'])\n",
    "gap_log = np.array(GAP_log['values'])\n",
    "gap_dct = np.array(GAP_out_dct['values'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12 12 13 13 13 13 13 13 13 13 13 13 12 12 12 12 12 12 12 13 14 13 13 13\n",
      " 13 13 13 13 13 13 13 13 13 13 12 12 12 10  9  9  9  8  8  7  7  7  7  7\n",
      "  7]\n",
      "[15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15.\n",
      " 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15.\n",
      " 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15. 15.]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(513, 94)"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if dtype == 'int' or dtype==\"fix16\" or dtype==\"fix32_scal\":\n",
    "    QIN = 15\n",
    "    QWin = QIN + Shift\n",
    "    if not high_prec:\n",
    "        if rad4:\n",
    "            QFFT = QIN + Shift - (int(np.log2(n_fft//2)) - 1)\n",
    "        else:\n",
    "            QFFT = QIN + Shift - (int(np.log2(n_fft//2)) - 1)\n",
    "    else:\n",
    "        QFFT = (QIN + Shift[:,np.newaxis] + fft_shift_buff)[:,:n_fft//2+1]\n",
    "    print(QFFT)\n",
    "\n",
    "    if use_power:\n",
    "        QSPECT = QFFT * 2\n",
    "    else:\n",
    "        QSPECT = 15 * np.ones(QFFT.shape)\n",
    "    print(QSPECT)\n",
    "    if not high_prec:\n",
    "        QMEL = QSPECT[:,np.newaxis] + 15 - melspect_shift_buff\n",
    "    else:\n",
    "        if use_power:\n",
    "            QMEL = 15 - 2 + 2*Shift[:,np.newaxis] - melspect_shift_buff\n",
    "        else:\n",
    "            QMEL = 30 - melspect_shift_buff\n",
    "    \n",
    "    #QLOG = 15\n",
    "    QLOG_NORM = 15 - Norm\n",
    "    QDCT = QLOG_NORM - 7\n",
    "stft.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "#win_qsnrs = []\n",
    "fft_qsnrs = []\n",
    "spect_qsnrs = []\n",
    "melspect_qsnrs = []\n",
    "logmel_qsnrs = []\n",
    "dct_qsnrs = []\n",
    "if dtype == 'int' or dtype==\"fix16\" or dtype==\"fix32_scal\":\n",
    "    for i in range(gap_windows.shape[0]):\n",
    "        fft_qsnrs.append(qsnr(np.abs(stft.T[i]), np.abs(gap_fft[i][:n_fft//2+1]) * 2.0**(-QFFT[i])))\n",
    "        spect_qsnrs.append(qsnr(spect.T[i], gap_spect[i] * 2.0**(-QSPECT[i])))\n",
    "\n",
    "        melspect_qsnrs.append(qsnr(mel_spect.T[i], gap_melspect[i] * 2.0**(-QMEL[i])))\n",
    "        logmel_qsnrs.append(qsnr(logmel.T[i], gap_log[i] * 2.0**(-QLOG_NORM[i])))\n",
    "        if ndct > 0:\n",
    "            dct_qsnrs.append(qsnr(mfcc.T[i], gap_dct[i] * 2.0**(-QDCT[i])))\n",
    "else:\n",
    "    for i in range(gap_windows.shape[0]):\n",
    "        fft_qsnrs.append(qsnr(np.abs(stft.T[i]), np.abs(gap_fft[i])[:n_fft//2+1]))\n",
    "        if use_power:\n",
    "            spect_qsnrs.append(qsnr(spect.T[i], gap_spect[i]))\n",
    "        else:\n",
    "            spect_qsnrs.append(qsnr(spect.T[i], gap_spect[i]))\n",
    "\n",
    "        melspect_qsnrs.append(qsnr(mel_spect.T[i], gap_melspect[i]))\n",
    "        logmel_qsnrs.append(qsnr(logmel.T[i], gap_log[i]))\n",
    "        if ndct > 0:\n",
    "            dct_qsnrs.append(qsnr(mfcc.T[i], gap_dct[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FFT:      avg: 45.41 min: 31@38\n",
      "SPECT:    avg: 42.33 min: 31@38\n",
      "MELSPECT: avg: 41.92 min: 34@38\n",
      "LOGMEL:   avg: 53.27 min: 27@43\n",
      "DCT:      avg: 41.00 min: 28@43\n"
     ]
    }
   ],
   "source": [
    "print(f\"FFT:      avg: {sum(fft_qsnrs)/len(fft_qsnrs):.2f} min: {min(fft_qsnrs)}@{fft_qsnrs.index(min(fft_qsnrs))}\")\n",
    "print(f\"SPECT:    avg: {sum(spect_qsnrs)/len(spect_qsnrs):.2f} min: {min(spect_qsnrs)}@{spect_qsnrs.index(min(spect_qsnrs))}\")\n",
    "print(f\"MELSPECT: avg: {sum(melspect_qsnrs)/len(melspect_qsnrs):.2f} min: {min(melspect_qsnrs)}@{melspect_qsnrs.index(min(melspect_qsnrs))}\")\n",
    "print(f\"LOGMEL:   avg: {sum(logmel_qsnrs)/len(logmel_qsnrs):.2f} min: {min(logmel_qsnrs)}@{logmel_qsnrs.index(min(logmel_qsnrs))}\")\n",
    "if ndct > 0:\n",
    "    print(f\"DCT:      avg: {sum(dct_qsnrs)/len(dct_qsnrs):.2f} min: {min(dct_qsnrs)}@{dct_qsnrs.index(min(dct_qsnrs))}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TESTING ONE FRAME"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f528f8728e0>]"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(librosa_fft_window)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "54 20\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "idx = 0\n",
    "frame = data[idx*config['frame_step']:idx*config['frame_step']+config['n_fft']]\n",
    "windowed_frame = frame * librosa_fft_window\n",
    "\n",
    "plt.plot(windowed_frame)\n",
    "#plt.plot(frame * np.hanning(frame_size))\n",
    "if dtype == 'int' or dtype==\"fix16\" or dtype==\"fix32_scal\":\n",
    "    plt.plot(gap_windows[idx] * 2.0**(-QWin[idx]))\n",
    "    print(qsnr(windowed_frame, gap_windows[idx] * 2.0**(-QWin[idx])), QWin[idx])\n",
    "else:\n",
    "    plt.plot(gap_windows[idx])\n",
    "    print(qsnr(windowed_frame, gap_windows[idx]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "47\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.abs(stft.T[idx]))\n",
    "if dtype == 'int' or dtype==\"fix16\" or dtype==\"fix32_scal\":\n",
    "    plt.plot(np.abs(gap_fft[idx])[:n_fft//2+1] * 2.0**(-QFFT[idx]))\n",
    "    print(qsnr(np.abs(stft.T[idx]), np.abs(gap_fft[idx])[:n_fft//2+1] * 2.0**(-QFFT[idx])))\n",
    "else:\n",
    "    plt.plot(np.abs(gap_fft[idx])[:n_fft//2+1])\n",
    "    print(qsnr(np.abs(stft.T[idx]), np.abs(gap_fft[idx])[:n_fft//2+1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "46\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(spect.T[idx])\n",
    "if dtype == 'int' or dtype==\"fix16\" or dtype==\"fix32_scal\":\n",
    "    plt.plot(gap_spect[idx] * 2.0**(-QSPECT[idx]))\n",
    "    print(qsnr(spect.T[idx], gap_spect[idx] * 2.0**(-QSPECT[idx])))\n",
    "else:\n",
    "    plt.plot(gap_spect[idx])\n",
    "    print(qsnr(spect.T[idx], gap_spect[idx]))    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(mel_spect.T[idx])\n",
    "if dtype == \"int\" or dtype==\"fix16\" or dtype==\"fix32_scal\":\n",
    "    plt.plot(gap_melspect[idx] * 2.0**(-QMEL[idx]))\n",
    "    print(qsnr(mel_spect.T[idx], gap_melspect[idx] * 2.0**(-QMEL[idx])))\n",
    "else:\n",
    "    plt.plot(gap_melspect[idx])\n",
    "    print(qsnr(mel_spect.T[idx], gap_melspect[idx]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "57\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAD4CAYAAAAJmJb0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABB6klEQVR4nO3dd3xc1Zn4/8+ZqpE06r3YcpN7twGD6WBMhxASQgtpZDchm+wmm7J8f5tks/l9s8mmbDZZCClAFkISOqHaBhuDe++2LMmW1XuXZjTlfP+YkZFt1Sma0eh5v156Id177rmPL/ajO+ee+xyltUYIIURsMkQ6ACGEEOEjSV4IIWKYJHkhhIhhkuSFECKGSZIXQogYZop0AANlZGTooqKiSIchhBATyp49e5q01pmD7YuqJF9UVMTu3bsjHYYQQkwoSqmKofbJcI0QQsQwSfJCCBHDJMkLIUQMkyQvhBAxLKgkr5T6iVLquFLqoFLqZaVUynn7pyilupRS3wgqSiGEEAEJ9k5+PbBAa70IKAG+c97+nwFvBXkOIYQQAQoqyWut12mt3f4ftwMF/fuUUncAp4AjwZxDCCFE4EI5Jv9Z/HftSqlE4FvA90c6SCn1sFJqt1Jqd2NjY0Anbqst58SfvkVTxdGAjhdCiFg1YpJXSm1QSh0e5Ov2AW0eBdzAs/5N3wN+rrXuGql/rfUTWusVWusVmZmDvrA1ooa6GmaXPE51yd6AjhdCiFg14huvWuvrhtuvlHoIuAW4Vn+0AsnFwMeVUj8GUgCvUsqhtf5VcOEOLjEtC4C+zsA+CQghRKwKqqyBUmot8E3gSq11T/92rfXlA9p8D+gKV4IHsKf6kry3uyVcpxBCiAkp2DH5XwF2YL1Sar9S6vEQxDRmiYlJOLQZeiTJCyHEQEHdyWutZ46izfeCOcdoKIOBdmXH6JAkL4QQA8XMG69dhiRMzrZIhyGEEFElZpJ8jymFOFdbpMMQQoioEjNJ3mlOJsHTHukwhBAiqsRMkndbU0j0dkY6DCGEiCoxk+S9tjSSdCfa64l0KEIIETViJskTn4ZRabramyMdiRBCRI2YSfLGhHQAulobIhyJEEJEj5hJ8ma7r+5Nd2t9hCMRQojoETNJ3pacAUBvu9SvEUKIfjGT5ONT+ouUyZi8EEL0i5kkn5SWA4CnqynCkQghRPSInSSfnIZLG9FSpEwIIc6KmSRvNBpoV4kYHK2RDkUIIaJGzCR58BUpMzvlTl4IIfrFVJLvNiZh7ZP6NUII0S+mkrzDnIrNLUleCCH6xVSSd1lSSPRKkhdCiH4xleQ9cakk6U44u564EEJMbjGV5IlPw6I8OLrbIh2JEEJEhZhK8v1FyjpapH6NEEJAjCV5c6Kvfk1Xq9SvEUIIiLEkb0nyVaJ0tEu5YSGEgBhL8gmpviTv7JAiZUIIATGW5O2pvkqUbilSJoQQQIwl+eTULLxaobvlTl4IISDGkrzFYqaDBJRD6tcIIQTEWJIH6DTYMTrbIh2GEEJEhZhL8l3GZKx9Um5YCCEgBpO8w5QsRcqEEMIv5pK805JKgqcj0mEIIURUiLkk741LJUlLkhdCCIjBJK9tqdjow+3ojnQoQggRcTGX5FWCr35NR6uUNhBCiJhL8qZEXyXKrlapRCmEEDGX5OOSfHfyPW1SiVIIIWIuyduSffVrnB2S5IUQIqgkr5T6iVLquFLqoFLqZaVUyoB9i5RS25RSR5RSh5RScUFHOwoJ/UXKOqVImRBCBHsnvx5YoLVeBJQA3wFQSpmAZ4C/01rPB64CXEGea1SS03xJ3tMj9WuEECKoJK+1Xqe1dvt/3A4U+L9fAxzUWh/wt2vWWnuCOddoxdtsdGobqkcqUQohRCjH5D8LvOX/vhjQSql3lFJ7lVLfHOogpdTDSqndSqndjY3Bj6MrpehQdowOqV8jhBCmkRoopTYAOYPselRr/aq/zaOAG3h2QL+rgZVAD/CuUmqP1vrd8zvRWj8BPAGwYsUKHcgf4nzdxiTMfW2h6EoIISa0EZO81vq64fYrpR4CbgGu1Vr3J+kqYLPWusnf5k1gGXBBkg+HHlMKia628TiVEEJEtWBn16wFvgncprXuGbDrHWChUire/xD2SuBoMOcaiz5LCvFSpEwIIUa+kx/BrwArsF4pBbBda/13WutWpdTPgF2ABt7UWr8R5LlGzW1NIamzc7xOJ4QQUSuoJK+1njnMvmfwTaMcd15bGon04HU5MZitkQhBCCGiQsy98Qqg4vvr18hbr0KIyS0mk7wx0Ve/plMqUQohJrmYTPJWu+9OvqdNKlEKISa3mEzyccmZADg6pH6NEGJyi8kkn5iaDUCfFCkTQkxyMZnkk/xJ3tstSV4IMbnFZJK32+30agv0SP0aIcTkFpNJ3mBQtKkkDA4pNyyEmNxiMskDdBnsWPrkTl4IMbnFbJLvNSVj7WuPdBhCCBFRMZvkHeYU4j2S5IUQk1vMJnm3JQW7VypRCiEmt5hN8l5bGnbdjfa4R24shBAR9NRj/8Gf//pcWPqO2SRPfDoGpentlLVehRDRq62rh9vqfsnChlfC0n/MJnljQhoAnS1SpEwIEb0ObHmLNNVFwuI7wtJ/zCZ5s91XibKrTZK8ECJ6uY+8hgMLUy+6NSz9x2yStyVnAeBolyQvhIhO3Y4+5rdv5lTyKpQ1MSzniNkkH5/iq0TZJ2PyQogotX/7e+SoFswLbw/bOWI2ydvTcgDwdEmSF0JEp56Dr+DGyLRLPxa2c8Rskk9OTqFPG9E9UolSCBF9nC43xc0bKUtcjjE+NWznidkkbzYZaVd2DL1Sv0YIEX0O7NnGVFWHnhueB679YjbJA3SqJEzOtkiHIYQQF2jf+xJerZh22d1hPU9MJ/luYzJWl9zJCyGii9vjZWrDu5THL8SakhvWc8V0kndakol3S/0aIUR0OXRwH8VU4Jp1c9jPFdNJvs+SSqJUohRChNmREyX8+Xc/wekaXa2sxt0vAlB0+SfDGRYQ40neE5eKXXeB1pEORQgRwxpf/zfuqfp3NrzwmxHber2a3Jr1nLYUY8ucFvbYYjrJY0vDrDz0dbdFOhIhRIxqae9kScd7AKw8/mPKK6uHbX+s5AQLdQld028cj/BiO8kbEtMB6Gypj3AkQohYtX/j86Sobk4v/ifSVTsn//RNvN6hRw+qtz0PwJTLwj9UAzGe5M3+JN/VKvVrhBDhEXf0eVpVCkW3PUrptPu4vucN3l3/t0Hbaq3JqFpHtWkKSYXzxyW+mE7ycUm++jW9HY0RjkQIEYvKz1Sy3LmT6oKbwGii+J4f0WLMoGjbv9DY1nVB+7KKMyxyH6Zlyg3jFmNMJ3lbiq8SpbNdkrwQIvRObnwGq3KTd+VDACirHdfaHzOLSrY9870L2p/a8gIm5SV/1SfGLcaYTvL2NF+Sd0uRMiFEiHm9mqzTr1FjKiRtxkVnt+de9DFK069mTeNTbNuz+5xjkk6/RYMhi7SZK8ctzphO8impmXi0wtsjSV6I8bD5xcc4sOO9SIcxLvYePMBSfZT24rtAqXP2Fd7333iUCcMbX6fH6QKgsraBJX37qM+//oL24RTTST7OYqadRAy9LZEORYiYV1NVwaqDj2LY8N1IhzIuGrb8LwDTr37ogn3WtEKaLv4WF3v3885ffg1AyYcvYlVusi4Ob62a88V0kgfoNCRhlCJlQoRd6frfYlYe5vYdprGhNtLhhFW3w8WchjcpT1iMdYgXmqbe8A9U2uZyedlPOVpeQVzpm7SqFLLnXTGuscZ8ku8yJGPta4t0GELENLfbw5SKF2lRKZiUl9ItL0c6pLDasfVdpqsa1OJh5robjKR88jFSVBfVz32VJY4dVGVfAwbj+AVKkEleKfUTpdRxpdRBpdTLSqkU/3azUupppdQhpdQxpdR3QhJtABzmJGzutkidXohJYe+Wtymihprl36CJVIwn3450SGHVt/c5+jBRtPreYdvZi5ZSMeshrndtJEE5SVtx1zhF+JFg7+TXAwu01ouAEqA/md8NWLXWC4HlwBeVUkVBnisgfZYUEjxSiVKIcHLs/CM9xDHn2k9Tkb6aud076entiXRYYVHT3MGKzveoSL8CNYoVnaZ//Ac0mbLpVAnkLbl+HCI8V1BJXmu9TmvdX3ZtO1DQvwtIUEqZABvQB0Qk07rj0rDrDilSFoDePg9v7ylBy7UTw6iub2B510bKs67HZEsifuGt2FUvR7bG5t383k0vkaE6SL74vlG1V9ZEUj7/CtYH/ooyWcMc3YVCOSb/WeAt//cvAN1ALXAG+E+t9aBTXJRSDyuldiuldjc2huGlpbhU4nDhcXaHvu8Yt/WNp7n6tUs5XVEe6VBEFDuy7ikSlJOsK78AwMxLbqYXC44jr0c4stDTWhN/7EU6lZ2sZbeN+jhTzjws01eHMbKhjZjklVIblFKHB/m6fUCbRwE38Kx/00WAB8gDpgFfV0pNH6x/rfUTWusVWusVmZmZQf+BLog/wV+kTOrXjJnl1LtYlYvWisORDkVEKbfHS075C9SYCsnyzxoxxyVSmriSGS2bcbs9EY4wtI6cqmaVazt1hTeCyRLpcEZlxCSvtb5Oa71gkK9XAZRSDwG3APfpjz7X3wu8rbV2aa0bgC3AijD9GYZlsmcA0NkqlSjHQmtNfsd+AHobT0U2GBG1duzcxiJ9gs55nzrnBR9dfCN5NHL0wLYIRhd6JZv+hE31kXv5Q5EOZdSCnV2zFvgmcJvWeuBTljPANf42CcAlwPFgzhUoqz/J97YNfSf/zqZNPPfMb8crpAmhqrqK6VQB4G05E+FoRLTq3PYH3BiZcd3nz9k+Y/VdeLWiZe+rEYos9PrcXvLPvEajOY/EmZdGOpxRC3ZM/leAHVivlNqvlHrcv/3XQKJS6giwC3hSa30wyHMFxJbsGwJydjQNur+krIwlGx/ixpPflQeMA1Ts33j2e3NnVQQjEdGqurmdFe3rOJV2Oaak7HP2JaTlUW6dQ3btxpj5d7Vt/yFW6sN0Fd85rmUJgmUK5mCt9cwhtnfhm0YZcYmpOQC4Oi9M8g5nHz1/eohi1QpAc0sz6ekZ4xpftHKf3kofJqrM00norYl0OCIK7Vn3HLepDlj9uUH3d069nqUnf0n5qVKmT581ztGFXtPWZzAoTcGVn4l0KGMS82+8JqX77uQHK1K2+6l/ZonnIMftvo9ezTUyi6RfZsteKqyzaU+YRrq7LtLhiCjj9nhJL/kLrcZ0MhbfNGibwkt8L/5UbJv4b7+29fQxr/ltqhLmY86aWL+wYj7J221xdOh46G09Z/vRTc+zuvYpdqfdgvmqfwago04eMAI0t7Yyy1NKV/ZK3EkFZOlmehyOSIclosjWfYe4xLuP1ll3g3HwAYGM6YupM2STWLF+nKMLvQ0b32WuOoNx8T2RDmXMYj7JK6VoV0mYHB9N0++oLSd/09coNUxj/ud+Q2r+DAD6misiFWZUKTvwARblwV68GlNaESblpaFafgGKjzR9+CRGpZly7cNDN1KKupxrWOjcR0PzxC337fZ4se79LU6s5K6+P9LhjFnMJ3mALkMS5v5KlG4nLU/fi0F7cN/1JLaERFKzCujTRnR7ZUTjjBY9Jz8AoHDxNSRkFwHQWlMawYhENKlu7WZ56xtUJi3HlDlj2LZpy28nTrk4vnXwNU8ngo17jrLGvZmG6XdCfFqkwxmzSZHke03JxLnbASh/9msUOY7xwfzvM2f+UgCUwUiTIQNzlzxgBEhq2MMZUxFWezppeb7xx54GuZMXPls3vMpU1UDCJZ8esW3h4mvpJB514q0R24bby1sOsfXY2GeKNb3/GFblIm/tP4UhqvCbFEneaUkhwd1Oy47nmH7qT7wW/zHW3PWFc9q0mbNJcMR2DezR6HE4Ke47SnPaMgDScqfh1QpviwxlCd/Qhf3Yc/SoeNJWjDyBTpksnE69jHmdW+nudY5DhIPrc3tZtO4TeP76AJ0O16iP23+qjuu6/kZV+mUYs2aHMcLwmRRJ3mNNIU23EP/219ini1ny0C8wGc/9o/fYcklzyVuxJw9tJ1H1Ypl+GQAGSxzNhjRMMld+1Cqau/naM1vpdrpHbjzBfHCojKs822iedhtY4kd1jGX+zaSrDg7tfDfM0Q3tRMkxZqgaLtd7efOVZ0c+wO/QO0+SqdpJv/4fwxhdeE2OJG9Lx4KbLq+FquseY0pW8gVt3PZ8MnULLldfBCKMHq3HNgNQuPTaj7aZs2Wu/Bi8+8qT/PjkLRw/Hns1f2o++CNxykXu1cM8cD3PjFV34MJI98HIFSyrP/w+AD0qnsXHfkplU+eIx9S09rC85jkabNOxzb4u3CGGzaRI8u6kQjxa8Uzeo9yyevmgbQwphZiUl6bayT0sYavdSb3KJCn7oyXNum35pLlkrvxoNLT3srziD1iUh56qQ5EOJ6R6+tzMbXqLetsMTAXLRn2cKSGVU/FLKGp+H7fHG8YIh2ao3E4PcTjX/idz1Bk2v/DLEY/ZtO5l5hkqMK360oR6w/V8kyLJZ1xyL1/N/xMP3v9Z1BD/s+IypgLQVjt5HzC63R6m9RyiLmXJuduTCsjWzTick/tTzmi8u/5vLDaUAeBqOh3ZYEJs+/7DLFMncRbfPuak55p1AzOo4vDh/eEJbhheryavcz9VCQtJveheahMXcF3tE+wrrR7ymJ4+N7nH/kCnMZm0VRNv2uRAkyLJL56Sxq8evom0hKFLgybl+O5cuxtPj1NU0afs5BGyVCtMWXXOdlPaVMzKQ53MlR+Ww+Uh6/Dv6DbYcWJBtcdWYbeWPb43V/NWjb1iSdGlHwegYfcroQxpVMoqayjWZ3AVXARKkXLnT8hWbRx/+YdD1tVZt3krV+o9dC54EMy2cY44tCZFkh+NDP8LUe7m2PqHORYNh31FyXIXXn3O9vgs3y/AtpqycY9pIln3wXau1jtpm3c/jaYcbN1D3ylONC6Pl4L6d2mwTMGUPXfMxydkz6DSXERG9XvjXrDszMGNGJQmY+5VANhmXEpl7hpu73qBdTsPXNDe69V4dzyORxnJvfbL4xprOEiS90u0J9OKHdUxeWeRGCp30EEiWdOXnLM9Nd9Xh66nQWr7DEVrjXv7Y3iUkbw1/0BnXC4pfbEzJXf3sVJW6CN0T78x4PHptsLrWOQ5Qlnl+P4bc5/ahhsDWXM/Kg+cf9ePMCsPznU/wOE6d2GTDw+XckPfBmoLb0Yl5Y5rrOEgSX6AZmMmcT2TcxaJb5GQfZxJWAiGc/9apOf5PuV4ZK78kLYcLuMG5zpqC29CJeXRl1hAjrceZ4ysjFSz42VMykveqk8E3EfexR/DpLyUbH4+hJENT2tNZuteqqzFKGvi2e2GjBk0znmAm93v8vLb6845pvLdx0lQTnLXfn3c4gwnSfIDdFhySOqbnHPlq6srKaKGvvyLL9hntNhoUqkyV34YlRse8yWGG74BgEqdSorqprZ+4i876fVqMqvW0WLKwjpl8Nlpo5E+axX1pjzySv8ybr/8qhrbmOc9SXfOygv25d32rziMCRTu/r80dvpe1Dpe08KVba9QnbIcc/7icYkx3CTJD+BMyCPDMzmT/Bn/IiEZc68cdH+rKYf4SfopZyQnqlu4su0lqlJWYi7wJQZbpm9J4+aqiV/z59CpKi72HqBlyprgphIaDHQueoglHGfbh++FLsBhlB7YQpxykTz78gt3xqfhWPV1VqsD/O2l/wVg11t/pEA1kXz1V8clvvEgSX4Ab1IBdnrp6WgZuXGM8ZzeghMzBfMHX9asOz5P5soPYc9bT5KnWki59mtntyX7h7i66if+c4xT217FqlzkXBz4UE2/6dc+TC9W3NufCEFkI+st+xCAvPMmE/RLv/rLtFjyubTsF2wtqWfemWdptuSTuPCWcYlvPEiSH8CcNgWApurJN4sko2Uvp61zMFjiBt3vsheSrRtlrvx5GjscLKx8hkbrFBLnf7R4Rnq+r7Cbq3liTzvVWpN0+i3aDSkkzloddH+GhFQq8m/mst5NHCsL/zOe5KY91JkKMNizBm9gsmJd+33mGCo588yXWK5K8F78d2Awhj228SJJfoD4zCIAOuon9j/MsWpuaWGmp5yu7BVDtjGmTsWiPDRM8jeCz7dx3assVOVwyZfOeWBtTMyghziMHRO7fHV5bRMXuXZTn3ddyBJf/pp/wKb6KFv/+MiNg9DU2cs811FaM4Z/jpCw9OPUJy/iHsMGelQ8masn1vJ+I5EkP0Bqnm8c1dE0uRLZqQPvY1Ye7MVXDNkmPqsIgNZJ+ClnKA6Xh8zDv6PTkETmZeeV3VWKZlP2hJ8rf3zL30hUDjJWfjxkfdqnLuVUwmIW1b5AW1dvyPo937FDu0lVXdhmXjZ8Q6VI/9hPAOhZ+ABY7WGLKRIkyQ+QlVuIU5vQrZPrhajukx/i1Yopi68ask3/XPlumSt/1rtbtnKl3kXbvAcGrcjYZcsjdYLPlbeWvkG3SiBt/rUjNx4D86ovMkU1sG3dX0La70Dtx32L3+QtumbEtqapl8Dn3yXjlu+FLZ5IkSQ/gNlkokFlYJpki4ckN+6mwjyNOPvQq97IXPlzaa1xb/0fPMpIwQ3/MGgbl72QXN1Ab9/EnCtf09zBcsd2qrKuBNPQJUECUbDqE7QY0kg9/BQeb3jegI2v20WbIRVL5sxRBrVi1OWTJxJJ8udpNWcR3zux777GotfhZFbfMVrSh68qaIpLoJkUTBN8jDlUth8p5Xrnu1QX3oKy5wzaxpA6lSTVQ03dxPz7dGjrW6SqLpKXfSz0nRvNNM6+l0u8+9i5Z2fIu+9yupnpPERDytIJXUEyFCTJn6c7LpeUSbR4yMmDW0lQTqzTB586OVCrOZt4qSsPQOX6x4hXTvJu/MaQbWz+mj8t1SfHK6yQUsf/hgMLOUtvDkv/09c+ggsTHZtH/wB2tHf9h48dY4pqxFi0auTGMU6S/HnciXlkeJvR7skxVbDtuG+RkClLRl4UwTfGLHPly+tauKLtJc6kXIwlb+GQ7VLzfMMEE3GufGuXg8VdH3Am7dKwDWGYk3Mpy7yWVR1vU1HbOGxbj1fzu6f/wHP//iANbd0j9t141LdISO6iwefHTyaS5M+XUohRadobQjQs0d1M5+PX420oCU1/IRZXu4s6lUVS9tQR2/bPle9zxd6ydmOx/72/kqNaSbrqkWHbpfrnyrsn4HOMfds2kK3aiFt0Z1jPk33NIySpHg69/dsh2zjdHv7wm5/xYPk3uN/7Gpv+/NMR+zVX7aCXOOILl4Yy3AlJkvx5+hcPaQlRWd2K7S9jr9tJycb/DUl/oeTxeJnRc5DalNH9QzCkTsGq3DTUTLykFSoerybj5Au0GdNJWXjTsG2VLZVubBjbJ95zDNfhV3FhovDiO8J6ntQ5l1NpnUlxxXP0OC9cYLunz80zv/43Plf3A1pSFlGduJBran/LvpLTQ/bpdHuY0n2QWvsCMJrCGP3EIEn+PPas/sVDQpPIuk/6hkOMldtC0l8oHT+8h3TVjpo6unHL/rryofoFOBFtO3iMS717aJlx58gJRClazDkk9Eyswm69Tjdz2zZxKmkFypYS3pMphXv55ynmDFs3/u2cXe29Lp7/5Tf5XOsvqM9aTc6X3yT97p+ToTooffHfhhyfP3qqktlU4C24sNjeZCRJ/jzp+b4XovpCtHhIetMuAAq6DoEnuoY56rY9h1crZl5216jap+T6plF2T8Ax5lCp//BpTMpLwTVfGFX7Lls+qROs5s/eXR8yRTVgmHvbuJyv6KoH6VSJWPb8/uyCIk2dDt76ry/x6a7fU1NwI7lffAks8cRNXUnllDu4zfEqr23aOmh/1Yc+wKg0mQtkPB4kyV8gPSWFFm1HhWCqoKu1kmx3Dfv1LGw4aCnbFYIIQ6PP5WFa3duUxS8iMXPKqI7JKPA9SJyIY8yh0NrlZEHjG1QlLMCSM2dUx7iTCsnVjXT2TpwH+d37X8SDYuploXvLdTjKkkBV0ce5tG8rB44eo7q1mw9/+RD3OP5KzYxPkvfZZ8+Zp1/w8f+LNhhJ3Px9WrovvK66YhseDCTPlJk1IEn+AgaDotGYibU7+KmCVfs3AFAy5+8BqD04PuVVR2PPrg+YTjWe+aOfA2222WkladLOlf9w83pmq0qMy+4b9TGG1CnYVS+1E2SuvMvjZXrTRk7FL8aclD1u5y1a+xUMSlPx1i84/N/3cIfrLeoWPEze/b+5oGaOSsqja8VXuJ4dvPDin8/Z5/Fqstv3U2MrhgGLhExmkuQH0W7Jwe4I/iN2b8kmOnQ8V954DxU6B8OZwT9eRkLHrj/jxsCMK0efsACazdnYJmldeXXgTzixkHvpvaM+Jj7LN8TVPEHmyh/av5uZVOIqDs/c+KHYsmdSmnwpt3f9hRu8m6lf+U1y7vrxkC8yZVz/ddot2Vxa+lMOnmk+u/1EdTML9UkcuRcuEjJZSZIfhMOWR7qnHoJccDitcRdHzAvITkngdOIS8jv2g9cbmiCD0N7Tx7yWDZxKugizPXNMx3bF5U24MeZQOHqmntWOTVTnXAtjeBiZ1r8+7gSpbNqy50UApq3+5LifO2PNN+hTVhqv+CHZNz86/JuqlnjMN3yfBYbTbHr+l3j9D2FPHdqKTfWROmfoYnuTjST5QXiS8knAgbu7NeA+3G3V5Liracvy3VG4Ci4hiS7aKg6GKsyA7fjgHQpVI9Yld4/5WLe9kGxvA64YWbt0tI5s/AspqpusKz47puOScn0P8j2tp8MQ1eAOV7fT5x77zYTWmpza9zhlKT47lXg8pc2/Bsv/qSbzmuHfP+gXv+wemlMXc0/HU7yy0/ceirN8CwDpcyXJ95MkPwhjaiEALbWBzyLpH49PKPY94c9e6KuEV33g3SCjC57rwAv0YaZw1dgfrBlSpxKnXDTUTp5xeafbQ+6pl2gxZZE4Z2zVGJUtlS4Sxu05xsFTtZx8/FO8vm7dyI3PU1ZexgJdQsfUNWGIbJSM5tG3VYrUO/+TLNVGyzv/QXuvi/TmPTSY84esJzQZSZIfRH/t9I66wJN8T8n7dGgbc5b6asLMnr2AWp2GrtgSihADVtnUycruTVSmrw5oDrTNv7BKc/XEX7t0tD7ce4hVej+ds+8KaOGMFksOCT3jU1f+2Bu/4k7jFpIO/m7Mx1bteAmA/EvGZ1ZNKBimXETbjDt4wPsa//+z77DQe4yOrKEXv5mMgk7ySqkfKKUOKqX2K6XWKaXy/NuVUuqXSqlS//7hyxxGkZQc38Oy3iAWD0lt2MlR0zyykhMAsJiNnIpfRG7bvqDH+oOxe/PrZKk2klfeE9DxKXmTr658y9Y/YlSagqtHNzf+fN22fNJc9WfngIfLqfo2Vjf6Zpus7N1CbUv7mI5POv0OtYYcMqYvCUN04ZNy2w9RBgP3nPkuaaqLhFmDLNo9iYXiTv4nWutFWuslwOvAv/q33wjM8n89DDwWgnONi+zcfJzajKc1sI/Yno46ct2VtGSe+8adI/8S0nULnTWRqWOjtcZ07GUcKo6MZYG96JKe7/sF6G6eHHPl69p6WdbyJlX2xRgzZgTUhzupkHwaaO8J71z5Xa//lnzVRP3s+0lWPRze/Mqoj21pbWG+cz81OddMvNK8yQV4L3mEpQbfp8vs+VdFNp4oE3SS11p3DPgxAei/Xbkd+KP22Q6kKKVygz3feLDbrNSRjqkzsNfRq/etByBh9rkPfzLm+cbnz+yPzLj8oYpGVvdtoS73moArC1oSkmnDPuHXLh2tLe+/xQxDLdaVDwbchymtiHjlpKYmfEM2DR09LDnzFHVx08m++2d0qkTijr886uNLPnwZq3KTsjS8BcnCJe6qf8Jpy8ZpTcOQMcpFQiaJkIzJK6V+qJSqBO7jozv5fGBgJqjybzv/2IeVUruVUrsbG4cvNzqeWkxZxPUE9gJLV8n7dOk4Zi8592Nj8YIVtGg77vIPQxHimB364FVSVReZq0Y/z3swLabJMVdea4310HM4lJXMiwOfUpiQ7av501YTvucYH77xLMWqCsPl/wgmKxVZ17K0dxsNLaObIWYoeZM27ExbOkFLAVgTsd7/HNa7fzfxPomE2aiSvFJqg1Lq8CBftwNorR/VWhcCzwKjm//kp7V+Qmu9Qmu9IjNzbHO2w6krLifgxUNSGnZwxDSPnNRz37iLs5gojVtIVuueUIQ4Ji6Pl+Ty1+gxJJIw94ag+uq05ZEywdcuHY19ZTVc4fqAuvwbglrcub/kcE9DeAq7dTlcTD/xBM2mbLIu+RQAySvvIVE5OLb5pRGP73M6md2xjdLU1RhMY5jdEm3yl8PM0K5FGwtGleS11tdprRcM8vXqeU2fBfqrXVUDhQP2Ffi3TQh9ifmkeVvAc2H50+F4OhvIc52hOeOiQff35F5MrreOzsbxXSx8y7FKrvLupHXq2qDX63QlFpDjbcAd43PlT2x6jiTVS/YVnwuqH3u2f658S3j+n29c9ypLKKF35ZfPTkEsWHo9rSqZuBOvjHj8iZ1vk6y6Mc27JSzxicgKxeyaWQN+vB047v/+NeBB/yybS4B2rfXEuf1LLsCAxtkytrHnmgO++fHxxYO/jJE690oAzuzdEFx8Y1S65SUSlYOsVWMrYzAYlToFm+qjoX7C/M4es54+N1MrX6HFnINtZpAv1sQl0aHsmDtD/xyjz+0lff+vaTcknzP7RxnNnM66jkU922ltbRm2j56Dr9GrLcy+9PaQxyciLxRj8j/yD90cBNYAX/VvfxMoB0qB3wJfCsG5xo0lzffGX3P12D5idx7fRLe2Urxk8GlcxYsvpUvbcJZ9EHSMo47J4aKg+k06TWmYZ14ZdH+2TN8YcyzPld+4Yy+XcJieefeAIfh/Jq3mHBIcoX+OsXnze1zq3Uvzgs9e8DA9eeU92FQfxzc/P+Tx2utlatP7HI9fji0h8CEpEb1CMbvmLv/QzSKt9a1a62r/dq21/rLWeobWeqHWenfw4Y6fxOwiALoaTo/puOT6nRwxziUvPWnQ/bY4Kyet80lvHr9x+fX7SrlK7aN31q0BvcxzvmR/XfmuCVKPJRBdO/6IQWnyr/pMSPrric8nw1Ub0rnyXq/GsO2/6MHGtLVfvWD/tGXX0kgaluPnj6p+pPLoDnJ0I44Za0MWl4gu8sbrENLzfHerzjHMB/d2NZHvOkVzxvAV8DpzVjLVU0F3a2APdseqdsdLxCkXmf6HcsE6W1e++XRI+os2TreHlZ0bqEhajkotCkmfnuQp5NNIU6czJP0BbN+7myv7PqB65j2o+NQL9iuDkVPZ17GwZwcdbc2D9AD1u17CoxXTR7lwjJh4JMkPITs9lUadBO2jnytfc9A3/z1u1vBDIvZi3/7Te8M/X76mrZe5zevosOagCkOzHJo1MZV2EjG2j+/D47F48Y03+dWP/jmgO+fTVdVMV7V0FwY/tNXPnO6r+VNXG7pr1vneL/AoI0W3/POQbZJW3oNFuSl5/8+D7s+s3sAx81yycwsH3S8mPknyQ7CajDSoTCxdo3+42HFsI73awswhxuP7zVp6BU5tpqc0/OPyb+86yuWGQ+j5d4ZkbLlfsymLuCidK+9weZi26994xPEEdY1NYz6+oXQfAElTFocspoRs3xBXqObKHzxRwlXd73Aq71bMKRe8fnJW8dKrqSUT6yBDNu01pRS5y2nOvz4kMYnoJEl+GO2WbBLHsHhIUv0ODhvnUJiZMmy7xIQESixzSG0M73KAWmva976IWXlIXhFYrZqhdMVF71z59ze/xzKOAVBdMvZHQb1VhwDImhm6cktpZ+fKh+Y5RvVbP8Os3BTe+p1h2xmMBsqz1jCnZzfdrQ3n7KvY6nsgm3XR6FcHExOPJPlh9NpySXM3jKqgmO5upqCvnMb00a1I0565kmmuUno724KMcmiHqtu5uGsjHQlTITd0d6UAffYCsr0NeDyRXwRlIK01nh2/xY3vAXNXxYEx92FuPkYnCVjSQjeEEe+v3qlbg6/5c6qqhstaX+Fk+jXE584esb195ScxKw+lm587Z7u17B3KKWD23ND+3RDRRZL8MNz2Amw40L0jvxpec8i3fmvcKOdUJxRfjlFpTu0L37qv67bt5RLDMSyL7w75q94qZSoJykljQ3QN2ew8Vs7Vzo1UFN5BJ/EYG46MuY/07lLqbTNCe82sibSrJCwhmCt//PX/Ikn1knXjt0fVfv6yyzlDDpYTHw3Z9HU2M6PnAKczr8ZgkDIAsUyS/DD6Fw8ZzVTBjmObcGgzM5eO7mHdjGVX49YGOks2BxXjUBwuD+Yjz2NQmrgVwb8Adb64/rryVdE1V75iw2+wqT4KbvgqtdYZpHWNreJnl8NFkaeCnpSR75DHqtWShz3IufJer2ZR7YucTFhO6szB36o+n9FooCxrDcXde3G0+obYKra9hEl5iV8UWDVSMXFIkh+GLdP3QlTrKFaISqzbzmHD7BHH4/slJaVSZp5JUkN4xuU3HK3jFu9G2jNXQtr0kPefnOPrs7M+eurKn2ns5OLml6m0L8FasJju1DlMdZ/G0Tf60hSny4+TpHox5c4PeXy9Cfmku+vPrkcaiKrqKvJVI12FV43puKSV9/g+OW7+EwCuo29Qr1NZdNHY+hETjyT5YST5qwf2Np4etp3uaSXfWUZj+krUGD7iN6evYIbzOE5HdzBhDmrftvXMMNRiv+SBkPcNkFFYDIAriurKb3nnz0xVDdiv8L1cbcxdSKJyUFF2bNR9tJTtByBt2tKQx+dNLiSfJho6egPuo/ak7yW65KljG0dftGwVZRRgPvEq2tVLUds2jtgvI94aXB0jEf0kyQ8jK6cAhzbjHmHxkNpDGzGgMc8Y24o0tpmXY1FuyveFdsimrt3BjOrXcBmsGOaHpz54nD2NTuIxRMlc+U6Hi4KTz9BuSidlmW+2SOp03+yYlrJ9o+7HVXsYgKwZS0Ieozm9CKtyUVcT+C/G7krfQvB5s5eP7dxGA6WZa5jec5C6zU8RjwNdfFPAcYiJQ5L8MDLtcdSQgaFj+Lny7cc24tRmZi69akz9T19+HV6taDu+KeAYB/Pq7jJuMWzDOesWiBu8vEIoNJlysI3T2qUjWbd5C5er/fQs+vTZSoy5M5fg1QpXzcFR9xPXepwGQyaG+JSQx2jPCX6uvKnpOB3YiUsdem78UJJXfgIDmqQPf0CntjHn0psDjkNMHJLkh2EwKJqNWSMmssTa7Rw2FDM1O21M/SenZVFhnEpCXejG5bXW1O96iSTVQ+JF4Rmq6dcZl0uyc/TvEYSL16vx7vwdLkzkXv13Z7ebbHZqjHnYWo8Pc/S5snvLaYoPz8pCafm+fh0jDP8NJ7W7lHrb9IBm/ixddhHHdBEJupu9lhXkZ6QEHIeYOCTJj6DTmk1S3xA1ZrTGuf4HFDpLqE6/dEzj8f0a05czw3GYrq6OkRuPwt4zbVzRvZ7uuByYFmSJ3BGo9BkUeqt48523wnqekWw+fIobXO9SX7AW7Nnn7GtOnEVO7+junJvaO5mqq+lLnxOOMLGmFwGgW08HdHxHbx9FnjP0pgY288dqMlKa5Xu7tbNoTUB9iIlHkvwInAl5vsVD3OcVlvK46XvlEaxb/pPnPVeSsebrAfVvX3IHCcpJzc+vpqYy+JWD3tm+n8sNBzEv+1RIKk4OZ95d/4dOUxpLt36JXYdH/3Az1Mree5Ik1UPO9V+5YJ87Yz6F1NHYPHiBroGqTh7ErDzE5S8MR5hgiafVkIq1K7C1g8tLj2NXvVjyFgQcQsoVX+SX7juZtjrw5QzFxCJJfgQ6qQAAT/uA+c19PbifuxfLgWf4tecO7J94nEuLA1ujfO5lt3HkisfI91Rh/v21HNsV+MtRvX0e4o4+j1FpLMvuD7if0TImZRP34F9JUd1YXniAirqRE2monajtYHXLSzQkzsE05cICbPGFiwCoOTFyaef20/sByAxhOYMLzmHJwe4IrBxEc9leADJmBD7z5/KFs7j3279h/tTskRuLmCBJfgTmdN9c+fZa/112dzOep27FULqO77o/w4xP/oi1C/OCOsf8a+6l+ZOv41Zmpr/+CXa++lhA/bxzuJZb9CY6MpfBOK1YnzB1GV03/prFnOTE7z9HR2/fuJy33/vrXma2oYqE1X8/6Dh1TvEKADor9o/Yl64/ggsjaVNCP0e+nyOhgCxPHe4AykH0z/xJnxZcGYKMRGtQx4uJRZL8CBKzigDoqD8FrRV4fr8GT80BHnF9jVX3fIu1CwK7gz/flLkrif/yZsqsc7lo37fZ9psv43G7x9TH3u3vUWyoJvGiB0MS02hlXnw3lYu/xhrXRt76zb/gCeJln7Fo6e5jStkz9BiTSFg++PBDat4MuojHMIryBontJdSYClFBroE7HG/yFHJporZ17O9G2NpKaDRmo+KSwxCZiFWS5EeQmlMEgKX8Xby/v57e1joedP0Lt33qiyFL8P2SM3KZ9Y317Ey/nVW1z3D4pzfR1TH8+pz9qtt6mVX7Gm6DFcOC8MyNH07hHd+jImcNd7f+jhee+924nPNvm3dyndqNY+F9YLYN3kgpqi3TSe4cvryB1pp8Zzlt9lnDtguWJaMIi/JQX3N6TMd5vJpcRzmtiTPCE5iIWZLkR5CbkUqjTiav+i1aejzc3fevPPSpT4U8wfczW+JY+cjTbJ/zL8zv2UXzL66g9tTId6Gv7CrnVsNWnDNvBFtKWGIbllJM/ezT1MUXc1PJ/8fbGzeF9XQujxfvricxKE3alX8/bNvOlDlMdZ3CPcwno5r6OnJVM97MeaEO9Rz9c+U76sZWDuJUfSvTqMGTMTccYYkYJkl+BElxJkqYyglvAXc6vsdXP3Vb2BJ8P6UUl9zzLY5e+zTJ3lZsT6/h/XdeGnKVI601dbteIUV1kxDmufHDssST9YUX8BjjmLvpYfYdD3620FA2HaniVs86mvOvgdSpw7Y15MwnUfVSdfrEkG3qTvoeaib4H9SGS/9ceWfD2JJ8/8yfxBAuZCImB0nyI1BK8cOk73Kb+0c8eu91YU/wAy264jY67n+HTmMql279PL//73+jqrXngnY7T7VwZe96euOyYPrV4xbfYExpUzDd+xy5qhnXnx+kqqk9LOdpP/A6GaqDFH+dmuGkTveVAGg8OfQMm+4zvoVCcmaNrVzAWJnT/L+Q2sZWDqLzjK8ufvas8M38EbFJkvwofOe2xTz5uVXjmuD7TZm5gPyvf0hDxkV8vuVnrP/FF3jqw9JzHm6+s/0AVxkOYFp6T9jnxo9G4sxVtF77n1zEYfb+4R/Dcg5z7S76MGOeMfILX3nFS/FqhbN66PIGhsajdBJPUnZRCKMchDmOFkMa1u6xzZVXDUdxY8SSFfoSyCK2SZIfhctnZXLpjIyInd8Qn0L+l16na/Fn+Yx6nYJ3Ps/9/7OBk/WddDvdxB1/EZPyYh6HufGjlX35ZziZeyvXd/+NfSdOh7TvPreX3O5jNCTMhlHMhLHGJ1FjzMXWMvQLWyldJ6m1Tgv54iqD6bDmkjTGuvIpnaU0WgpH9ecVYiBJ8hOF0UTinT9H3/gTrjEd5PtNX+fzv3yJLz+7h9t4n66MJZAZXXd5BTf+EzbVx9F1vw1pv0erW5lPOe6cJaM+pilhJlm9gz8jcLs9THGdpiu5OEQRDq/PXkiWp57GTufIjYHW7j6KvKfpDsNCJiL2SZKfYNTFD2O473lmWlv5W9x3KSh7jjmGysg+cB2CbcoyahPns6LxFUrqQlObB6D82F4SlJPUWatGfYwzfR753jo6Oi5cyrGqopQk1QPZgZcLGIuUgtnkqWY+ODy6Rb1LKqopUE0Yw7CQiYh9kuQnopnXYvj8BpKSUvh385N4DRbUwrsiHdWg7KsfZrahinVvvzpy41HqObUDgOSZF5YxGEp8wWIMSlN1fO8F+xr99eZTisZn5krmwuswKS+1+98eVft6f3zhWMhExD5J8hNV5mz4wntQfCOGS74IttRIRzSoxGWfwGFMpLDsOWraAl8R6Zw+mw7QY0iAtNG/GJRd7Js103H6wiTvqPbNrMkrDu/Mmn5qyiochgQya9/H4fKM2N5Z43tPYqyrQQkBkuQntvg0uPfPsObfIx3J0CzxuBZ8krWGHfxp4+hXaBpKQ4eDGa4SWlMWgGH0f30zC2bRiQ3qL3yxzNp8jHqVQZx9bOsBBMxoprPgcq5Q+/iwpHHE5taW4/QqGyQXjkNwItZIkhdhZ7/sC1iVG73vWdp6gitgtv9UHXNUJcaCsd11K4OBKvN0kjsufCEqvaeUBtv4lgtIXXwrOaqVI/u2DNvO5fGS3VtGS/yMMf1SE6Kf/K0R4Zc1l57ci/g46/nj1tE9bBxK7YldmJWH9OJLxnxsZ/JsCvtO4R1QAdLhcFDoqQp4IY5AmYp9i3eYy9fjHaagW1lDJ8WqEpeUMxABkiQvxkX8qoeZZqjn6NbX6e0beRx6KJ7K3QCYp6wc87EqZwGJqpe6ypNnt1WePIhFeTDnhmmhkKHYs2lNWcDF7t0cqGobsln56XJSVRe2gnGOT8QMSfJifMy7DZc1jdtcb/P8nsqAuuhze0lvP0yHOQOSxl7DP6loCQD1JR+tqdtyyvecIH36+D/UtM27kaWqlA8PDF1Tp/20r5xB+nSZWSMCI0lejA+TFdPy+7nBuJsX398d0KIZx+s6WEAZPRmBJeSC2cvxanV2Ng2Ap/YILm0kd+b4J/m4eTdiUJruo+8M2UbX+R4Um3JkjrwIjCR5MW7U8ocw4uXyzrd549DYl8A7XFrBDEMt8dMvCuj8CfYUagw5WJuPnt0W33aCamM+ZktcQH0GJW8pvZY05nZtp6J58EVE7B0ldJjSICF9nIMTsUKSvBg/6TPQ06/mActGnth0csjSyUNpKd0JQFKASR6gIX4Wmd2lZ3/O7i2jOTG8C4UMyWDAM/06rjQc4N2jF/7Sa+x0UuQ5TWfS+JRbELFJkrwYV2rFZ8nWTWQ3fMDmk01jOtZc559nnxf4+LQzfQ753lp6uzpob2sml0Zc6XMC7i9YiQtvIkV1U7H//Qv2HatuZZaqRmXLUI0IXFBJXin1A6XUQaXUfqXUOqVUnn/7ff7th5RSW5VS8qqe8Jl9Izoxm89YN/L4ptEvKtLQ6aDIeYJ225Sg3u619pc3OLGH2hO++vJxBeFdKGRY06/Gi5HshvcveIeg5tRR4pRr3MotiNgU7J38T7TWi7TWS4DXgX/1bz8FXKm1Xgj8AHgiyPOIWGE0o5Y9yGq9lzPlxzlQ2Taqw/adaWOxoQx3bnCzTLJn+l6iaj+9j47+hThmRnDmii2F7pwVXK32senEuW+/9lT66t/Hy/RJEYSgkrzWemBpwQRA+7dv1Vr3l/vbDhQEcx4RY5Z9GpTiwbj3eWyUd/MlpSfIUa0kzRh9UbLB5E6dTZe24a07DPVH6dQ2cgojNCbvl7DgZuYazrDr4OFztpubj+NFQWbkhpPExBf0mLxS6odKqUrgPj66kx/oc8Bbwxz/sFJqt1Jqd2PjyHU8RAxIKUTNWsN95vd592gVpQ1dIx7iOB34S1ADGYwGzpinkdR+HHtHCVWWIlSEywUYitcAYC7fQJ/bN7XU6faQ2VtGW1wBWOIjGZ6Y4Eb8262U2qCUOjzI1+0AWutHtdaFwLPAI+cdezW+JP+tofrXWj+htV6htV6RmZkZ3J9GTBwrPkuiq5mbTHt5/P3h7+ZdHi/25oN4MEJO8EMX7cmzye8rJ7/vFO32KJi5kjmH3vh8LvPuYXt5MwAn67uYRSXONLmLF8EZMclrra/TWi8Y5Ov8AuHPAmeLmiulFgG/A27XWjeHNmwx4c28DlKm8PWkd3llXzXVw5QhPl7byXxd6lu5yWwL/txZ87HTSxLd6KwoqAmjFOa5a7nMcJiNR3xvA5+oaqBI1WHNG5+FTETsCnZ2zcDBzNuB4/7tU4CXgAe01iXBnEPEKIMRVn2FKd2HWK6O89vN5UM23XemmUWGcoyFK0Jy6qSijx602gujY+aKafYNxCsnrUc3orWm5dQhjEqT7C/FIESggh2M/JF/6OYgsAb4qn/7vwLpwP/4p1fuDvI8IhYtvR/i0/lu6jr+vOsMzV2Dr3laWXqYZNVDwrTgxuP79Zc3AMidPT4LhYyo6HLcBiuLe3dwtLYDd53vIaxRyhmIIAU7u+Yu/9DNIq31rVrrav/2z2utU7XWS/xfobkFE7HFEg8X/x3zurZR5DnNk1tOD9rMW+Wbz64KQvPXKDkllWpDDnWkk56RHZI+g2aJxzv1cq4y7Gf90XoS2k7gUhZImx7pyMQEJ2+8isha+XkwJ/C9tA08ve00nQ7XObubupwU9BzDZYiDjNDVfD+Sczv7M28PWX+hYJm7lmmGerbt2EGRp4IO+wzfsJYQQZAkLyIrPg2WP8TF3RtJctTy7I4z5+zufwnKkbkQjKaQnXbtF/+DtV/+ecj6C4lZvqmUC3q2M9tQic6MgofCYsKTJC8ib9WXUcrAdzPe4/cfnjpncev9pxuZryqwFYVmPD6qpU7FmVrMncYPyVZtJE6JYLkFETMkyYvIS86HRZ/g2t53cHc28sKeqrO7msv3YlUuTCGaWRPtLHPXssBwGoC4fClnIIInSV5Eh8u+itHj4Ftpm/nN5jLcHi9ujxdrg6++DHnLIhvfOFH+IRsAsmRmjQieJHkRHTJnw+yb+Zj7TZpbWnn9YC3H6zqZ5y3FaUmB1KJIRzg+plwC1mRfpU17TqSjETFAkryIHqv/EUtfG48kb+GxTWXsPdPKIkMZ3tyloFSkoxsfRjMsewDm3DJ5/swirCTJi+hRuBKmXsZDhjcor2/l6U1HKTZUEzd1Ejx0HeiGH8Ltv4p0FCJGSJIX0WX1PxLfW8en7btI6ziGEW/IXoISYjKSJC+iy8zrIHsBj1jeYKnhpG/bJHnoKkQ4SJIX0UUpuOxrpHSX85X49XiSCiFRSlALEShJ8iL6zL8TUqZgdzVhLJC7eCGCIUleRB+jCVZ9xfd9fpRUiRRiggpdMRAhQmnZA9BWAQvvjnQkQkxokuRFdDLbfFMJhRBBkeEaIYSIYZLkhRAihkmSF0KIGCZJXgghYpgkeSGEiGGS5IUQIoZJkhdCiBgmSV4IIWKY0lpHOoazlFKNQEUQXWQATSEKJ9QktsBIbIGR2AIzUWObqrUetJJfVCX5YCmldmuto7L4uMQWGIktMBJbYGIxNhmuEUKIGCZJXgghYlisJfknIh3AMCS2wEhsgZHYAhNzscXUmLwQQohzxdqdvBBCiAEkyQshRAyLiSSvlFqrlDqhlCpVSn070vEMpJQ6rZQ6pJTar5TaHeFY/qCUalBKHR6wLU0ptV4pddL/39Qoiu17Sqlq/7Xbr5S6KUKxFSqlNiqljiqljiilvurfHvFrN0xsEb92Sqk4pdROpdQBf2zf92+fppTa4f/3+hellCWKYntKKXVqwHVbMt6xDYjRqJTap5R63f9zYNdNaz2hvwAjUAZMByzAAWBepOMaEN9pICPScfhjuQJYBhwesO3HwLf9338b+I8oiu17wDei4LrlAsv839uBEmBeNFy7YWKL+LUDFJDo/94M7AAuAf4K3OPf/jjw91EU21PAxyP9d84f1z8BfwJe9/8c0HWLhTv5i4BSrXW51roP+DNwe4Rjikpa681Ay3mbbwee9n//NHDHeMbUb4jYooLWulZrvdf/fSdwDMgnCq7dMLFFnPbp8v9o9n9p4BrgBf/2SF23oWKLCkqpAuBm4Hf+nxUBXrdYSPL5QOWAn6uIkr/kfhpYp5Tao5R6ONLBDCJba13r/74OyI5kMIN4RCl10D+cE5GhpIGUUkXAUnx3flF17c6LDaLg2vmHHPYDDcB6fJ+627TWbn+TiP17PT82rXX/dfuh/7r9XClljURswC+AbwJe/8/pBHjdYiHJR7vVWutlwI3Al5VSV0Q6oKFo3+fAqLmbAR4DZgBLgFrgp5EMRimVCLwIfE1r3TFwX6Sv3SCxRcW101p7tNZLgAJ8n7rnRCKOwZwfm1JqAfAdfDGuBNKAb413XEqpW4AGrfWeUPQXC0m+Gigc8HOBf1tU0FpX+//bALyM7y96NKlXSuUC+P/bEOF4ztJa1/v/IXqB3xLBa6eUMuNLos9qrV/yb46KazdYbNF07fzxtAEbgVVAilLK5N8V8X+vA2Jb6x/+0lprJ/AkkblulwG3KaVO4xt+vgb4LwK8brGQ5HcBs/xPni3APcBrEY4JAKVUglLK3v89sAY4PPxR4+414NP+7z8NvBrBWM7Rn0D97iRC184/Hvp74JjW+mcDdkX82g0VWzRcO6VUplIqxf+9Dbge3zODjcDH/c0idd0Gi+34gF/aCt+Y97hfN631d7TWBVrrInz57D2t9X0Eet0i/QQ5RE+hb8I3q6AMeDTS8QyIazq+2T4HgCORjg14Dt9Hdxe+Mb3P4Rvrexc4CWwA0qIotv8FDgEH8SXU3AjFthrfUMxBYL//66ZouHbDxBbxawcsAvb5YzgM/Kt/+3RgJ1AKPA9Yoyi29/zX7TDwDP4ZOJH6Aq7io9k1AV03KWsghBAxLBaGa4QQQgxBkrwQQsQwSfJCCBHDJMkLIUQMkyQvhBAxTJK8EELEMEnyQggRw/4f+B/dUyqnAA8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(logmel.T[idx])\n",
    "#plt.plot(power_to_db(mel_spect.T[idx], amin=1e-4))\n",
    "if dtype == \"int\" or dtype==\"fix16\" or dtype==\"fix32_scal\":\n",
    "    plt.plot(gap_log[idx] * 2.0**(-QLOG_NORM[idx]))\n",
    "    print(qsnr(logmel.T[idx], gap_log[idx] * 2.0**(-QLOG_NORM[idx])))\n",
    "else:\n",
    "    plt.plot(gap_log[idx])\n",
    "    print(qsnr(logmel.T[idx], gap_log[idx]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43\n",
      "maxdiff: [-0.00709128 -0.01465084  0.00909493  0.03860377  0.00581893  0.0381368\n",
      "  0.01595782  0.0437807   0.00218719  0.01385958 -0.08440981  0.10212963\n",
      "  0.00963918  0.03379961  0.01035531  0.00692902  0.04215028 -0.02302769\n",
      " -0.02179878  0.00752696 -0.1209354  -0.01219896  0.01223537  0.00321886\n",
      " -0.01166543 -0.05655996  0.10701546  0.12857117  0.03488265  0.00686894\n",
      "  0.01764042 -0.0616458   0.02432222  0.04471287  0.07437198  0.04766781\n",
      "  0.51536363  0.10792658 -0.11509156 -0.01611201]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(mfcc.T[idx])\n",
    "if dtype == \"int\" or dtype==\"fix16\" or dtype==\"fix32_scal\":\n",
    "    plt.plot(gap_dct[idx] * 2.0**(-QDCT[idx]))\n",
    "    print(qsnr(mfcc.T[idx], gap_dct[idx] * 2.0**(-QDCT[idx])))\n",
    "    print(f\"maxdiff: {np.abs(mfcc.T[idx]- gap_dct[idx] * 2.0**(-QDCT[idx])) / mfcc.T[idx]}\")\n",
    "else:\n",
    "    plt.plot(gap_dct[idx])\n",
    "    print(qsnr(mfcc.T[idx], gap_dct[idx]))\n",
    "#plt.plot(scipy.fftpack.dct(gap_log[idx] * 2.0**(-QLOG_NORM[idx]), axis=0, type=2, norm=None))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "MSE = np.sum(np.abs(mfcc.T[:49,:] - gap_dct* 2.0**(-QDCT[idx]))**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [],
   "source": [
    "SUM = np.sum(mfcc.T[:49,:]**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "38.68865390184027"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10* np.log10(SUM/MSE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
